home *** CD-ROM | disk | FTP | other *** search
/ DOpus Plus / DOpus Plus.iso / Tutorial / C Guide / RndPic_module / ModuleEntry.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-09-20  |  33.4 KB  |  722 lines
  1.  
  2. #include "includes/Project.h"
  3. #include "includes/Window.h"
  4.  
  5. ModuleInfo module_info =
  6. {
  7.     1,
  8.     "rndpic.module",
  9.     "rndpic.catalog",
  10.     MODULEF_CALL_STARTUP|MODULEF_STARTUP_SYNC|MODULEF_HELP_AVAILABLE,
  11.     2,                      
  12.     { 0, COMMAND_0, MSG_RNDPIC_DESC, NULL, NULL }
  13. };
  14.  
  15. ModuleFunction module_func[1] =
  16. { { 1, COMMAND_1, MSG_CHANGE_DESC, NULL, NULL } };
  17.  
  18. /********************************************************************/
  19.  
  20. extern BOOL ReadConfig( PrefsData *pd, BOOL test );
  21. extern BOOL WriteConfig( PrefsData *pd, BOOL test );
  22.  
  23. void ChooseFiles( IPCData *ipc, char *args );
  24. void __saveds SendMsgs( void );
  25.  
  26. void Prefs( IPCData *ipc, struct Screen *screen, IPCData *main_ipc );
  27. BOOL HandleWin( RPData *rp );
  28.                
  29. void DisEnable( ObjectList *olist, ULONG id );
  30.  
  31. void SendRMsg( STRPTR cmd, struct MsgPort *receiver );
  32. struct MsgPort *CheckPort( void );
  33.  
  34. /********************************************************************/
  35.  
  36. static char version[] = "$VER: " VERSION_STRING " " __AMIGADATE__;
  37.  
  38. char type[3][8] = { {"Desktop"}, {"Lister"}, {"Req"} }; 
  39. char precision[5][6] = { {"None"}, {"GUI"}, {"Icon"}, {"Image"}, {"Exact"} };
  40. STRPTR guide = "RndPic.guide";
  41.  
  42. /********************************************************************/
  43.  
  44. int __asm __saveds L_Module_Entry( register __a0 char *args,              
  45.                                    register __a1 struct Screen *screen,   
  46.                                    register __a2 IPCData *ipc,
  47.                                    register __a3 IPCData *main_ipc,
  48.                                    register __d0 ULONG mod_id,
  49.                                    register __d1 EXT_FUNC(func_callback) )
  50. {
  51.     switch( mod_id )
  52.       {
  53.          case 0:                Prefs( ipc, screen, main_ipc );
  54.                                 break;
  55.                    
  56.          case 1:                ChooseFiles( ipc, args );
  57.                                 break;
  58.                                 
  59.          case FUNCID_STARTUP:   ChooseFiles( ipc, NULL );
  60.          
  61.       }
  62.     
  63.     return 1;
  64. }
  65.  
  66. /********************************************************************/
  67.  
  68. void Prefs( IPCData *ipc, struct Screen *screen, IPCData *main_ipc )
  69. {
  70.      RPData *rp;
  71.      
  72.      NewConfigWindow ncfgwin;
  73.      
  74.      // Only startable, if nothing else is working ...
  75.      
  76.      if( ((struct Library *) getreg(REG_A6))->lib_OpenCnt < 2 )
  77.        {
  78.           if( (rp = AllocMemH(mempool, sizeof(RPData))) )
  79.             {
  80.                rp->dc.dc_Count = DOPUS_HOOK_COUNT;
  81.                IPC_Command( main_ipc, HOOKCMD_GET_CALLBACKS, NULL, &rp->dc, NULL, REPLY_NO_PORT );
  82.                
  83.                ncfgwin.nw_Parent = screen;
  84.                ncfgwin.nw_Title  = VERSION_STRING;
  85.                ncfgwin.nw_Dims   = &cfgwin;
  86.                ncfgwin.nw_Locale = locale;
  87.                ncfgwin.nw_Port   = NULL;
  88.                ncfgwin.nw_Flags  = WINDOW_SCREEN_PARENT | WINDOW_VISITOR |
  89.                                    WINDOW_REQ_FILL | WINDOW_AUTO_KEYS;
  90.                ncfgwin.nw_Font   = NULL; 
  91.                
  92.                rp->prefswin = OpenConfigWindow(&ncfgwin);
  93.                rp->ipc = ipc;
  94.                rp->pd.db.middledelay = 200;
  95.                rp->pd.db.startdelay = 180;
  96.                                    
  97.                rp->olist = AddObjectList( rp->prefswin, winobjects );
  98.                
  99.                ReadConfig( &rp->pd, FALSE );
  100.                
  101.                for( rp->running = 0; rp->running < 3; rp->running++ )
  102.                  {
  103.                     SetGadgetValue( rp->olist, (rp->running * 4) + GADGET_ID_STRING_DESKTOP, (ULONG) rp->pd.rpd[rp->running].path );
  104.                     
  105.                     if( rp->pd.rpd[rp->running].flags & RANDOM_ENABLED )
  106.                          SetGadgetValue( rp->olist, (rp->running * 4) + GADGET_ID_TXT_DESKTOP, TRUE );
  107.                     else
  108.                          DisEnable( rp->olist, (rp->running * 4) + GADGET_ID_TXT_DESKTOP );
  109.                  }
  110.                                              
  111.                if( rp->pd.rpd[3].flags )
  112.                  {
  113.                     rp->modelist = AddObjectList( rp->prefswin, delay_objects );
  114.                     SetGadgetValue( rp->olist, GADGET_ID_BUTTON_DELAY, TRUE );
  115.                     SetGadgetValue( rp->olist, GADGET_ID_BUTTON_COPIED, FALSE );
  116.                     SetGadgetValue( rp->olist, GADGET_ID_SLIDER_DELAY, rp->pd.db.startdelay );
  117.                     DisableObject( rp->olist, GADGET_ID_BUTTON_TEST, FALSE );
  118.                     DisableObject( rp->olist, GADGET_ID_POP_DESKTOP, FALSE );
  119.                                                                            
  120.                  }
  121.                else
  122.                  {
  123.                     rp->modelist = AddObjectList( rp->prefswin, copy_objects );
  124.                     SetGadgetValue( rp->olist, GADGET_ID_BUTTON_DELAY , FALSE );
  125.                     SetGadgetValue( rp->olist, GADGET_ID_BUTTON_COPIED, TRUE );
  126.                                                      
  127.                     SetGadgetValue( rp->olist, GADGET_ID_STRING_COPIED, (ULONG) rp->pd.rpd[3].path );
  128.                     DisableObject(  rp->olist, GADGET_ID_BUTTON_TEST  , TRUE );
  129.                     DisableObject(  rp->olist, GADGET_ID_POP_DESKTOP  , TRUE );
  130.                     DisableObject(  rp->olist, GADGET_ID_POP_LISTER   , TRUE );
  131.                     DisableObject(  rp->olist, GADGET_ID_POP_REQUESTER, TRUE );
  132.                  }
  133.                
  134.                rp->gads[0] = GADGET( GetObject(rp->olist, GADGET_ID_POP_DESKTOP));
  135.                
  136.                // preparing popups...
  137.                                             
  138.                NewList( (struct List *) &rp->popmenu.item_list );
  139.                rp->popmenu.locale = locale;
  140.                rp->popmenu.flags = 0;
  141.                
  142.                for( rp->running = MSG_POPUP;
  143.                     rp->running < MSG_POPUP + 8;
  144.                     rp->running++ )
  145.                   {
  146.                      if( (rp->popitem = AllocMemH(mempool, sizeof(PopUpItem))) )
  147.                        {
  148.                           if( rp->running != MSG_POPUP + 2 )
  149.                             {
  150.                                rp->popitem->item_name = (char *) rp->running;
  151.                             }
  152.                           else
  153.                                rp->popitem->item_name = POPUP_BARLABEL;
  154.                                
  155.                           rp->popitem->id = rp->running - MSG_POPUP;                             
  156.                           AddTail( (struct List *) &rp->popmenu.item_list, (struct Node *) &rp->popitem->node );
  157.                        }
  158.                   }
  159.                
  160.                rp->popitem->flags |= POPUPF_CHECKED;
  161.                               
  162.                while( WaitPort(rp->prefswin->UserPort) && HandleWin(rp) ); 
  163.                
  164.                while( !IsListEmpty((struct List *) &rp->popmenu.item_list) )
  165.                   FreeMemH( RemTail((struct List *) &rp->popmenu.item_list) );
  166.                   
  167.                CloseConfigWindow( rp->prefswin );
  168.                FreeMemH( rp );
  169.             }
  170.        } 
  171. }
  172.  
  173. /********************************************************************/
  174.  
  175. BOOL HandleWin( RPData *rp )
  176. {
  177.      rp->running = TRUE;
  178.      
  179.      while( (rp->imsg = GetWindowMsg(rp->prefswin->UserPort)) && rp->running )
  180.        {
  181.           switch( rp->imsg->Class )
  182.             {
  183.                case IDCMP_CLOSEWINDOW:
  184.                      
  185.                     rp->running = FALSE;
  186.                     break;
  187.                     
  188.                case IDCMP_GADGETDOWN:
  189.                     
  190.                     for( rp->misc = 0; rp->misc < 8; rp->misc++ )
  191.                       {
  192.                          if( rp->misc != 2 )
  193.                            {
  194.                               (rp->popitem = GetPopUpItem(&rp->popmenu, rp->misc))->flags = POPUPF_LOCALE|POPUPF_CHECKIT;
  195.                           
  196.                               if( rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags & 1 << rp->misc )
  197.                                    GetPopUpItem( &rp->popmenu, rp->misc )->flags |= POPUPF_CHECKED;
  198.                            }
  199.                       }
  200.                     
  201.                     if( DoPopUpMenu(rp->prefswin, &rp->popmenu, &rp->popitem, SELECTDOWN) != -1 )
  202.                       {
  203.                          if( rp->popitem->id < 2 )
  204.                            {
  205.                               if( (rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags ^= 1 << (rp->popitem->id)) & 1 << rp->popitem->id &&
  206.                                   (rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags & 1 << (!rp->popitem->id)) )
  207.                                    rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags ^= 1 << (!rp->popitem->id);
  208.                            }
  209.                     
  210.                          else
  211.                            {
  212.                               for( rp->misc = 3; rp->misc < 8; rp->misc++ )
  213.                                 {
  214.                                    if( rp->popitem->id == rp->misc )
  215.                                         rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags |= 1 << rp->misc;
  216.                                    else
  217.                                      {
  218.                                         if( rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags & 1 << rp->misc )
  219.                                              rp->pd.rpd[(GET_ID(rp->imsg)-GADGET_ID_POP_DESKTOP)/4].flags ^= 1 << rp->misc;
  220.                                      }
  221.                                 }
  222.                            }
  223.                       }
  224.                   
  225.                     // switch the button again off  
  226.                     GADGET((rp->cur = GetObject(rp->olist, GET_ID(rp->imsg))))->Flags &= ~GFLG_SELECTED;
  227.                     RefreshGList( GADGET(rp->cur), rp->prefswin, 0, 1 );                     
  228.                     break;
  229.                
  230.                case IDCMP_MOUSEMOVE:
  231.                       
  232.                     if( GET_ID(rp->imsg) == GADGET_ID_SLIDER_DELAY )
  233.                       {
  234.                          if( GetGadgetValue(rp->olist, GADGET_ID_CYCLE_DELAY) )
  235.                               rp->pd.db.middledelay = rp->imsg->Code;
  236.                          else
  237.                               rp->pd.db.startdelay = rp->imsg->Code;
  238.                        }
  239.                      break; 
  240.                
  241.                case IDCMP_RAWKEY:
  242.                                                              
  243.                     if( rp->imsg->Code = 0x5F )
  244.                       {
  245.                          rp->misc = GADGET_ID_TXT_DESKTOP;
  246.                          rp->cur = 0;
  247.                          
  248.                          for( rp->misc = GADGET_ID_TXT_DESKTOP;
  249.                               rp->misc <= GADGET_ID_BUTTON_CANCEL;
  250.                               rp->misc++ )
  251.                            {
  252.                               if( (rp->cur = GetObject(rp->olist, rp->misc)) &&
  253.                                   rp->cur->type == OD_GADGET && 
  254.                                   CheckObjectArea(rp->cur, rp->imsg->MouseX, rp->imsg->MouseY) )
  255.                                 {
  256.                                    sprintf( rp->buffer, "%ld", rp->misc );
  257.                                    rp->dc.dc_ShowHelp( guide, rp->buffer );
  258.                                    
  259.                                 }
  260.                            }
  261.                       }
  262.                     break;         
  263.                                             
  264.                case IDCMP_GADGETUP:
  265.                     
  266.                     switch( GET_ID(rp->imsg) )
  267.                       {                       
  268.                          case GADGET_ID_TXT_DESKTOP:
  269.                          
  270.                               rp->pd.rpd[0].flags ^= RANDOM_ENABLED;
  271.                               DisEnable( rp->olist, GADGET_ID_TXT_DESKTOP );
  272.                               break;
  273.                                                                            
  274.                          case GADGET_ID_TXT_LISTER: 
  275.                               
  276.                               DisEnable( rp->olist, GADGET_ID_TXT_LISTER );
  277.                               rp->pd.rpd[1].flags ^= RANDOM_ENABLED;
  278.                               break;
  279.                         
  280.                          case GADGET_ID_STRING_LISTER: break;
  281.                                                                            
  282.                          case GADGET_ID_TXT_REQUESTER: 
  283.                               
  284.                               DisEnable( rp->olist, GADGET_ID_TXT_REQUESTER );
  285.                               rp->pd.rpd[2].flags ^= RANDOM_ENABLED;
  286.                               break;
  287.                                                        
  288.                          case GADGET_ID_STRING_REQUESTER: break;
  289.                          
  290.                          case GADGET_ID_BUTTON_COPIED:
  291.                               
  292.                               if( GetGadgetValue(rp->olist, GADGET_ID_BUTTON_DELAY) )
  293.                                 {
  294.                                    SetGadgetValue( rp->olist, GADGET_ID_BUTTON_DELAY, FALSE );
  295.                                    FreeObjectList( rp->modelist );
  296.                                    DisplayObject( rp->prefswin, GetObject(rp->olist, GADGET_ID_BEVEL_MODESETTINGS), -1, -1, NULL );
  297.                                    rp->modelist = AddObjectList( rp->prefswin, copy_objects );
  298.                                    DisableObject( rp->olist, GADGET_ID_POP_DESKTOP, TRUE );
  299.                                    DisableObject( rp->olist, GADGET_ID_POP_LISTER, TRUE );
  300.                                    DisableObject( rp->olist, GADGET_ID_POP_REQUESTER, TRUE );
  301.                                    
  302.                                    DisableObject( rp->olist, GADGET_ID_BUTTON_TEST, TRUE );
  303.                                    
  304.                                    SetGadgetValue( rp->olist, GADGET_ID_STRING_COPIED, (ULONG) rp->pd.rpd[3].path );
  305.                                    
  306.                                 }
  307.                               else
  308.                                    SetGadgetValue( rp->olist, GADGET_ID_BUTTON_COPIED, TRUE );
  309.                               
  310.                               break;
  311.                               
  312.                          case GADGET_ID_BUTTON_DELAY:
  313.                               
  314.                               if( GetGadgetValue(rp->olist, GADGET_ID_BUTTON_COPIED) )
  315.                                 {
  316.                                    SetGadgetValue( rp->olist, GADGET_ID_BUTTON_COPIED, FALSE );
  317.                                    FreeObjectList( rp->modelist );
  318.                                    DisplayObject( rp->prefswin, GetObject(rp->olist, GADGET_ID_BEVEL_MODESETTINGS), -1, -1, NULL );
  319.                                    rp->modelist = AddObjectList( rp->prefswin, delay_objects );
  320.                                    
  321.                                    if( rp->pd.rpd[3].flags & CYCLE_MIDDLE ) 
  322.                                      {
  323.                                         SetGadgetValue( rp->olist, GADGET_ID_CYCLE_DELAY, 1 );
  324.                                         SetGadgetValue( rp->olist, GADGET_ID_SLIDER_DELAY, rp->pd.db.middledelay );
  325.                                      }
  326.                                    else
  327.                                      {
  328.                                         SetGadgetValue( rp->olist, GADGET_ID_SLIDER_DELAY, rp->pd.db.startdelay );
  329.                                      }
  330.                                      
  331.                                    DisableObject( rp->olist, GADGET_ID_POP_DESKTOP, FALSE|!GetGadgetValue(rp->olist, GADGET_ID_TXT_DESKTOP) );
  332.                                    DisableObject( rp->olist, GADGET_ID_POP_LISTER, FALSE|!GetGadgetValue(rp->olist, GADGET_ID_TXT_LISTER) );
  333.                                    DisableObject( rp->olist, GADGET_ID_POP_REQUESTER, FALSE|!GetGadgetValue(rp->olist, GADGET_ID_TXT_REQUESTER) );
  334.                                    
  335.                                    DisableObject( rp->olist, GADGET_ID_BUTTON_TEST, FALSE );
  336.                                    
  337.                                 }
  338.                               else
  339.                                    SetGadgetValue( rp->olist, GADGET_ID_BUTTON_DELAY, TRUE );
  340.                               break;
  341.                               
  342.                          case GADGET_ID_CYCLE_DELAY:
  343.                               
  344.                               rp->pd.rpd[3].flags ^= CYCLE_MIDDLE;
  345.                               
  346.                               if( GetGadgetValue(rp->olist, GADGET_ID_CYCLE_DELAY) )
  347.                                 {
  348.                                    SetGadgetValue( rp->olist, GADGET_ID_SLIDER_DELAY, rp->pd.db.middledelay );
  349.                                 }
  350.                               else
  351.                                 {
  352.                                    SetGadgetValue( rp->olist, GADGET_ID_SLIDER_DELAY, rp->pd.db.startdelay );
  353.                                 }
  354.                               
  355.                               break;
  356.                         
  357.                          
  358.                          case GADGET_ID_STRING_COPIED:
  359.                               
  360.                               strcpy( rp->pd.rpd[3].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_COPIED) );
  361.                               
  362.                               break; 
  363.                               
  364.                          case GADGET_ID_BUTTON_TEST: 
  365.                          
  366.                               SetBusyPointer( rp->prefswin );
  367.                               strcpy( rp->pd.rpd[0].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_DESKTOP) );
  368.                               strcpy( rp->pd.rpd[1].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_LISTER) );
  369.                               strcpy( rp->pd.rpd[2].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_REQUESTER) );
  370.                               
  371.                               rp->pd.rpd[3].flags = GetGadgetValue( rp->olist, GADGET_ID_BUTTON_DELAY );
  372.                                                                                  
  373.                               WriteConfig( &rp->pd, TRUE );
  374.                               
  375.                               if( (rp->misc = (ULONG) CheckPort()) )
  376.                                    SendRMsg( "Command wait RndPic hhh", (struct MsgPort *) rp->misc ); 
  377.                                    
  378.                               DeleteFile( TEST_CONFIG );
  379.                               ClearPointer( rp->prefswin );
  380.                               break;
  381.                               
  382.                          case GADGET_ID_BUTTON_SAVE: 
  383.                               
  384.                               strcpy( rp->pd.rpd[0].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_DESKTOP) );
  385.                               strcpy( rp->pd.rpd[1].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_LISTER) );
  386.                               strcpy( rp->pd.rpd[2].path, (STRPTR) GetGadgetValue(rp->olist, GADGET_ID_STRING_REQUESTER) );
  387.                               
  388.                               rp->pd.rpd[3].flags = GetGadgetValue( rp->olist, GADGET_ID_BUTTON_DELAY );
  389.                                                                                           
  390.                               WriteConfig( &rp->pd, FALSE );
  391.                                                                                                                         
  392.                          case GADGET_ID_BUTTON_CANCEL: 
  393.                          
  394.                               rp->running = FALSE;
  395.                               break;
  396.                       }          
  397.             }
  398.           ReplyWindowMsg( rp->imsg );
  399.        } 
  400.      return (BOOL) rp->running;
  401. }
  402.  
  403. /********************************************************************/
  404. // the "working" process
  405.  
  406. void ChooseFiles( IPCData *ipc, char *args )
  407. {
  408.      RndData *rd;
  409.      PassData *pd = NULL;
  410.      
  411.      if( (rd = AllocMemH(mempool, sizeof(RndData))) )
  412.       {
  413.          rd->pd.db.startdelay  = 180;
  414.          rd->pd.db.middledelay = 200;
  415.          
  416.          if( ReadConfig(&rd->pd, (args && args[0])) && 
  417.              ((rd->pd.rpd[0].flags | rd->pd.rpd[1].flags | rd->pd.rpd[2].flags) & RANDOM_ENABLED) )
  418.            {
  419.               if( rd->pd.rpd[3].flags )
  420.                 {
  421.                    if( !(pd = AllocMemH(mempool, sizeof(PassData))) )
  422.                      {
  423.                         FreeMemH( rd );
  424.                         return;
  425.                      }
  426.                    else
  427.                      {
  428.                         pd->a4 = getreg(REG_A4);
  429.                         pd->library = DOpusBase;
  430.                         pd->module  = (struct Library *) getreg(REG_A6);
  431.                      }  
  432.                 }
  433.                 
  434.               if( (rd->eac = AllocDosObject(DOS_EXALLCONTROL,NULL)) )
  435.                 {
  436.                    if( (rd->fib = AllocDosObject(DOS_FIB, NULL)) )
  437.                      {
  438.                         if( (rd->dirlist = Att_NewList( LISTF_POOL)) )
  439.                           {
  440.                              for( rd->count = 0; rd->count < 3; rd->count++ )
  441.                                {
  442.                                   if( rd->pd.rpd[rd->count].flags & RANDOM_ENABLED )
  443.                                     {
  444.                                        strcpy( rd->buffer, FilePart(rd->pd.rpd[rd->count].path) );
  445.                                        rd->pd.rpd[rd->count].path[strlen(rd->pd.rpd[rd->count].path) - strlen(rd->buffer) - 1] = 0;
  446.                                         
  447.                                        if( (rd->lock = Lock( rd->pd.rpd[rd->count].path, SHARED_LOCK)) )
  448.                                          {
  449.                                             Examine( rd->lock, rd->fib );
  450.                              
  451.                                             if( rd->fib->fib_DirEntryType > 0 )
  452.                                               {
  453.                                                  rd->eac->eac_LastKey = 0;
  454.                                                  rd->more = 0;
  455.                                                   
  456.                                                   while( rd->buffer[rd->more] )
  457.                                                          rd->buffer[rd->more] = ToUpper( rd->buffer[rd->more++] );
  458.                                              
  459.                                                   ParsePatternNoCase( rd->buffer, rd->puffer, 256 );
  460.                                                   rd->eac->eac_MatchString = rd->puffer;  
  461.                                              
  462.                                                   do
  463.                                                     {
  464.                                                        rd->ead = (APTR) rd->mem;
  465.                                                 
  466.                                                        if( (!(rd->more = ExAll(rd->lock, rd->ead, 4096, ED_TYPE, rd->eac)) &&
  467.                                                             IoErr() != ERROR_NO_MORE_ENTRIES) )
  468.                                                             break;
  469.                                                                                           
  470.                                                        if( !rd->eac->eac_Entries )
  471.                                                             continue;
  472.                                
  473.                                                        do
  474.                                                          {
  475.                                                             if( rd->ead->ed_Type < 0 && Stricmp(&rd->ead->ed_Name[strlen(rd->ead->ed_Name)-5], ".info") )
  476.                                                               {
  477.                                                                  strcpy( rd->buffer, rd->pd.rpd[rd->count].path );
  478.                                                                  AddPart( rd->buffer, rd->ead->ed_Name, 256 );
  479.                                                                  Att_NewNode( rd->dirlist, rd->buffer, NULL, NULL );
  480.                                                               }
  481.                                                          }
  482.                                                        while( (rd->ead = rd->ead->ed_Next) );
  483.                                                     }
  484.                                                   while( rd->more );
  485.                                               }
  486.                                             UnLock( rd->lock );
  487.                                              
  488.                                             if( (rd->more = Att_NodeCount(rd->dirlist)) )
  489.                                               {
  490.                                                  Seed( ((LONG) rd->dirlist)/(rd->mem[Random(300)]+1) ); 
  491.                                                  rd->more = Random( rd->more );
  492.                                                  strcpy( rd->pd.rpd[rd->count].path, Att_NodeName( rd->dirlist, rd->more) );
  493.                                               }
  494.                                             else
  495.                                                  rd->pd.rpd[rd->count].path[0] = 0;
  496.                                                   
  497.                                             Att_RemList( rd->dirlist, REMLISTF_SAVELIST );
  498.                                          }       
  499.                                     }
  500.                                }
  501.                                                                                                                                                                               
  502.                              for( rd->count = 0; rd->count < 3; rd->count++ )
  503.                                {
  504.                                   if( (rd->pd.rpd[rd->count].flags & RANDOM_ENABLED) &&
  505.                                        rd->pd.rpd[rd->count].path[0] )
  506.                                     {
  507.                                        sprintf( rd->puffer, "Background.%ld", rd->count );
  508.                                         
  509.                                        if( pd )
  510.                                          {
  511.                                             for( rd->lock = 3; !(rd->pd.rpd[rd->count].flags & (1 << rd->lock)) && (rd->lock < 8); 
  512.                                                  rd->lock++ );
  513.                                         
  514.                                             sprintf( pd->pd.rpd[rd->count].path, 
  515.                                                      "%s %s %s %s %s%s %s",
  516.                                                      DOpusBase->lib_Version > 63 ? "DOpus set background" : "Command SetAsBackground", 
  517.                                                      DOpusBase->lib_Version > 63 ? rd->pd.rpd[rd->count].path : type[rd->count],
  518.                                                      DOpusBase->lib_Version > 63 ? type[rd->count] : rd->pd.rpd[rd->count].path,
  519.                                                      DOpusBase->lib_Version > 63 ? "custom" : NULL,
  520.                                                      rd->lock == 8 ? NULL : "Precision=",
  521.                                                      rd->lock == 8 ? NULL : precision[rd->lock-3],
  522.                                                      (rd->pd.rpd[rd->count].flags & CENTER_PIC) ? "Center" : ((rd->pd.rpd[rd->count].flags & TILE_PIC) ? "Tile" : NULL) );
  523.                                                                                 
  524.                                          }
  525.                                        else
  526.                                          {
  527.                                             strcpy( rd->buffer, rd->pd.rpd[3].path );
  528.                                             AddPart( rd->buffer, rd->puffer, 256 );
  529.                                             DeleteFile( rd->buffer );
  530.                                             MakeLink( rd->buffer, (LONG) rd->pd.rpd[rd->count].path, LINK_SOFT );
  531.                                             
  532.                                          }                          
  533.                                     }
  534.                                }  
  535.                                        
  536.                              if( pd )
  537.                                {
  538.                                   pd->pd.db.startdelay  = rd->pd.db.startdelay;
  539.                                   pd->pd.db.middledelay = rd->pd.db.middledelay;
  540.                                   
  541.                                   if( !args )
  542.                                        pd->pd.rpd[3].flags |= STARTUP;
  543.                                     
  544.                                   if( !(IPC_Launch(0, &rd->sender, "RndPicSender",
  545.                                        (ULONG) SendMsgs, 4000, (ULONG) pd,
  546.                                        DOSBase)) ) 
  547.                                        FreeMemH( pd );
  548.                                       
  549.                                }
  550.                               Att_RemList( rd->dirlist, NULL );     
  551.                           }
  552.                         FreeDosObject( DOS_FIB, rd->fib );
  553.                      }                                                     
  554.                    FreeDosObject( DOS_EXALLCONTROL, rd->eac );
  555.                 }
  556.            }
  557.          FreeMemH( rd );
  558.       }
  559. }
  560.  
  561. /********************************************************************/
  562. // the commanding process (the callbacks did not work here..., ask me
  563. not for the reason.)
  564.  
  565. ULONG __asm __saveds send_startup( register __a0 IPCData *ipc,
  566.                                    register __a1 PassData *pd )
  567. {
  568.         struct Library *DOpusBase;
  569.         
  570.         putreg( REG_A4,pd->a4 );
  571.         pd->ipc = ipc;
  572.         DOpusBase = pd->library;  
  573.         
  574.         ++pd->module->lib_OpenCnt;
  575.         
  576.         return 1;
  577. }  
  578.  
  579. void __saveds SendMsgs( void )
  580. {       
  581.      IPCData *ipc;
  582.      struct Library *DOpusBase;
  583.      PassData *pd;
  584.      
  585.      if (!(DOpusBase=(struct Library *)FindName(&((struct ExecBase *)*((ULONG *)4))->LibList,"dopus5.library")))
  586.          return;
  587.  
  588.      ipc = IPC_ProcStartup( (ULONG *) &pd, send_startup);
  589.  
  590.      putreg( REG_A4, pd->a4 );
  591.  
  592.      if( !ipc )
  593.        {
  594.           IPC_Free( pd->ipc );
  595.           FreeMemH( pd ); 
  596.           return;
  597.        }  
  598.            
  599.      if( (pd->source = CreateMsgPort()) )
  600.        {
  601.           if( (pd->rmsg = CreateRexxMsg(pd->source, NULL, NULL)) )
  602.             {
  603.                pd->rmsg->rm_Action = 0;
  604.                
  605.                if( pd->pd.rpd[3].flags & STARTUP )
  606.                  {
  607.                     while( !(pd->receiver = CheckPort()) )
  608.                          Delay( 50 );
  609.                     
  610.                     if( DOpusBase->lib_Version > 63 )
  611.                          Delay(200);
  612.                     Delay( pd->pd.db.startdelay );
  613.                  } 
  614.                else
  615.                     pd->receiver = CheckPort();
  616.                       
  617.                for( pd->pd.db.startdelay = 0; pd->pd.db.startdelay < 3; pd->pd.db.startdelay++ )
  618.                  {
  619.                      ARG0(pd->rmsg) = pd->pd.rpd[pd->pd.db.startdelay].path;
  620.                      FillRexxMsg( pd->rmsg, 1, 0 );
  621.                      PutMsg( pd->receiver, (struct Message *) pd->rmsg );
  622.                     
  623.                      WaitPort( pd->source );
  624.                      GetMsg( pd->source );
  625.                     
  626.                      ClearRexxMsg( pd->rmsg, 1 );
  627.                      if( DOpusBase->lib_Version < 64 )
  628.                           Delay( pd->pd.db.middledelay );
  629.                      else
  630.                           Delay( 50 );
  631.                      
  632.                   
  633.                   }
  634.                 if( DOpusBase->lib_Version > 63 )
  635.                   {
  636.                      ARG0(pd->rmsg) = "dopus refresh background custom";
  637.                      FillRexxMsg( pd->rmsg, 1, 0 );
  638.                      PutMsg( pd->receiver, (struct Message *) pd->rmsg );
  639.                     
  640.                      WaitPort( pd->source );
  641.                      GetMsg( pd->source );
  642.                     
  643.                      ClearRexxMsg( pd->rmsg, 1 );
  644.                   }
  645.                 
  646.                   
  647.                 DeleteRexxMsg( pd->rmsg );
  648.             }
  649.           DeleteMsgPort( pd->source );
  650.        }
  651.      --pd->module->lib_OpenCnt;
  652.      IPC_Free( pd->ipc );
  653.      FreeMemH( pd );
  654.      
  655.       
  656. } 
  657.  
  658. /********************************************************************/
  659.  
  660.  
  661. void DisEnable( ObjectList *olist,  ULONG id )
  662. {
  663.      BOOL state = (BOOL) GetGadgetValue( olist, id );
  664.      DisableObject( olist, id+1, !state );
  665.      DisableObject( olist, id+2, !state );
  666.      DisableObject( olist, id+3, (!state)|GetGadgetValue(olist, GADGET_ID_BUTTON_COPIED) );
  667. }
  668.  
  669. /********************************************************************/
  670.  
  671. void SendRMsg( STRPTR cmd, struct MsgPort *receiver )
  672. {  
  673.      struct MsgPort *source;
  674.      struct RexxMsg *rmsg;
  675.         
  676.           if( (source = CreateMsgPort()) )
  677.             {
  678.                if( (rmsg = CreateRexxMsg(source, NULL, NULL)) )
  679.                  {
  680.                     
  681.                     rmsg->rm_Action = 0;
  682.                     ARG0(rmsg) = cmd;
  683.                     FillRexxMsg( rmsg, 1, 0 );
  684.                     PutMsg( receiver, (struct Message *) rmsg );
  685.                     
  686.                     WaitPort( source );
  687.                     GetMsg( source );
  688.                     
  689.                     ClearRexxMsg( rmsg, 1 );
  690.                     
  691.                     DeleteRexxMsg( rmsg );
  692.                   }
  693.                 DeleteMsgPort( source );
  694.               }
  695.       
  696. } 
  697.  
  698. /********************************************************************/
  699.  
  700. struct MsgPort *CheckPort( void )
  701. {
  702.    struct MsgPort *ret;
  703.    Forbid();
  704.    
  705.    ret = FindPort( "DOPUS.1" );
  706.    
  707.    Permit();
  708.    
  709.    return ret;
  710. }
  711.  
  712. /********************************************************************/
  713.  
  714. // function to set the values for the slider in 10 steps
  715.  
  716. LONG ChangeValue( struct Gadget *gad, LONG value )
  717. {
  718.    return( (value = value/10) * 10 );
  719. }
  720.  
  721.  
  722.